home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / sunrpc / sched.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  9KB  |  278 lines
  1. /*
  2.  * linux/include/linux/sunrpc/sched.h
  3.  *
  4.  * Scheduling primitives for kernel Sun RPC.
  5.  *
  6.  * Copyright (C) 1996, Olaf Kirch <okir@monad.swb.de>
  7.  */
  8.  
  9. #ifndef _LINUX_SUNRPC_SCHED_H_
  10. #define _LINUX_SUNRPC_SCHED_H_
  11.  
  12. #include <linux/timer.h>
  13. #include <linux/sunrpc/types.h>
  14. #include <linux/spinlock.h>
  15. #include <linux/wait.h>
  16. #include <linux/workqueue.h>
  17. #include <linux/sunrpc/xdr.h>
  18.  
  19. /*
  20.  * This is the actual RPC procedure call info.
  21.  */
  22. struct rpc_procinfo;
  23. struct rpc_message {
  24.     struct rpc_procinfo *    rpc_proc;    /* Procedure information */
  25.     void *            rpc_argp;    /* Arguments */
  26.     void *            rpc_resp;    /* Result */
  27.     struct rpc_cred *    rpc_cred;    /* Credentials */
  28. };
  29.  
  30. struct rpc_wait_queue;
  31. struct rpc_wait {
  32.     struct list_head    list;        /* wait queue links */
  33.     struct list_head    links;        /* Links to related tasks */
  34.     wait_queue_head_t    waitq;        /* sync: sleep on this q */
  35.     struct rpc_wait_queue *    rpc_waitq;    /* RPC wait queue we're on */
  36. };
  37.  
  38. /*
  39.  * This is the RPC task struct
  40.  */
  41. struct rpc_task {
  42. #ifdef RPC_DEBUG
  43.     unsigned long        tk_magic;    /* 0xf00baa */
  44. #endif
  45.     struct list_head    tk_task;    /* global list of tasks */
  46.     struct rpc_clnt *    tk_client;    /* RPC client */
  47.     struct rpc_rqst *    tk_rqstp;    /* RPC request */
  48.     int            tk_status;    /* result of last operation */
  49.  
  50.     /*
  51.      * RPC call state
  52.      */
  53.     struct rpc_message    tk_msg;        /* RPC call info */
  54.     __u32 *            tk_buffer;    /* XDR buffer */
  55.     size_t            tk_bufsize;
  56.     __u8            tk_garb_retry,
  57.                 tk_cred_retry,
  58.                 tk_suid_retry;
  59.  
  60.     unsigned long        tk_cookie;    /* Cookie for batching tasks */
  61.  
  62.     /*
  63.      * timeout_fn   to be executed by timer bottom half
  64.      * callback    to be executed after waking up
  65.      * action    next procedure for async tasks
  66.      * exit        exit async task and report to caller
  67.      */
  68.     void            (*tk_timeout_fn)(struct rpc_task *);
  69.     void            (*tk_callback)(struct rpc_task *);
  70.     void            (*tk_action)(struct rpc_task *);
  71.     void            (*tk_exit)(struct rpc_task *);
  72.     void            (*tk_release)(struct rpc_task *);
  73.     void *            tk_calldata;
  74.  
  75.     /*
  76.      * tk_timer is used for async processing by the RPC scheduling
  77.      * primitives. You should not access this directly unless
  78.      * you have a pathological interest in kernel oopses.
  79.      */
  80.     struct timer_list    tk_timer;    /* kernel timer */
  81.     unsigned long        tk_timeout;    /* timeout for rpc_sleep() */
  82.     unsigned short        tk_flags;    /* misc flags */
  83.     unsigned char        tk_active   : 1;/* Task has been activated */
  84.     unsigned char        tk_priority : 2;/* Task priority */
  85.     unsigned long        tk_runstate;    /* Task run status */
  86.     struct workqueue_struct    *tk_workqueue;    /* Normally rpciod, but could
  87.                          * be any workqueue
  88.                          */
  89.     union {
  90.         struct work_struct    tk_work;    /* Async task work queue */
  91.         struct rpc_wait        tk_wait;    /* RPC wait */
  92.     } u;
  93. #ifdef RPC_DEBUG
  94.     unsigned short        tk_pid;        /* debugging aid */
  95. #endif
  96. };
  97. #define tk_auth            tk_client->cl_auth
  98. #define tk_xprt            tk_client->cl_xprt
  99.  
  100. /* support walking a list of tasks on a wait queue */
  101. #define    task_for_each(task, pos, head) \
  102.     list_for_each(pos, head) \
  103.         if ((task=list_entry(pos, struct rpc_task, u.tk_wait.list)),1)
  104.  
  105. #define    task_for_first(task, head) \
  106.     if (!list_empty(head) &&  \
  107.         ((task=list_entry((head)->next, struct rpc_task, u.tk_wait.list)),1))
  108.  
  109. /* .. and walking list of all tasks */
  110. #define    alltask_for_each(task, pos, head) \
  111.     list_for_each(pos, head) \
  112.         if ((task=list_entry(pos, struct rpc_task, tk_task)),1)
  113.  
  114. typedef void            (*rpc_action)(struct rpc_task *);
  115.  
  116. /*
  117.  * RPC task flags
  118.  */
  119. #define RPC_TASK_ASYNC        0x0001        /* is an async task */
  120. #define RPC_TASK_SWAPPER    0x0002        /* is swapping in/out */
  121. #define RPC_TASK_SETUID        0x0004        /* is setuid process */
  122. #define RPC_TASK_CHILD        0x0008        /* is child of other task */
  123. #define RPC_CALL_REALUID    0x0010        /* try using real uid */
  124. #define RPC_CALL_MAJORSEEN    0x0020        /* major timeout seen */
  125. #define RPC_TASK_ROOTCREDS    0x0040        /* force root creds */
  126. #define RPC_TASK_DYNAMIC    0x0080        /* task was kmalloc'ed */
  127. #define RPC_TASK_KILLED        0x0100        /* task was killed */
  128. #define RPC_TASK_SOFT        0x0200        /* Use soft timeouts */
  129. #define RPC_TASK_NOINTR        0x0400        /* uninterruptible task */
  130.  
  131. #define RPC_IS_ASYNC(t)        ((t)->tk_flags & RPC_TASK_ASYNC)
  132. #define RPC_IS_SETUID(t)    ((t)->tk_flags & RPC_TASK_SETUID)
  133. #define RPC_IS_CHILD(t)        ((t)->tk_flags & RPC_TASK_CHILD)
  134. #define RPC_IS_SWAPPER(t)    ((t)->tk_flags & RPC_TASK_SWAPPER)
  135. #define RPC_DO_ROOTOVERRIDE(t)    ((t)->tk_flags & RPC_TASK_ROOTCREDS)
  136. #define RPC_ASSASSINATED(t)    ((t)->tk_flags & RPC_TASK_KILLED)
  137. #define RPC_IS_ACTIVATED(t)    ((t)->tk_active)
  138. #define RPC_DO_CALLBACK(t)    ((t)->tk_callback != NULL)
  139. #define RPC_IS_SOFT(t)        ((t)->tk_flags & RPC_TASK_SOFT)
  140. #define RPC_TASK_UNINTERRUPTIBLE(t) ((t)->tk_flags & RPC_TASK_NOINTR)
  141.  
  142. #define RPC_TASK_RUNNING    0
  143. #define RPC_TASK_QUEUED        1
  144. #define RPC_TASK_WAKEUP        2
  145. #define RPC_TASK_HAS_TIMER    3
  146.  
  147. #define RPC_IS_RUNNING(t)    (test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
  148. #define rpc_set_running(t)    (set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
  149. #define rpc_test_and_set_running(t) \
  150.                 (test_and_set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate))
  151. #define rpc_clear_running(t)    \
  152.     do { \
  153.         smp_mb__before_clear_bit(); \
  154.         clear_bit(RPC_TASK_RUNNING, &(t)->tk_runstate); \
  155.         smp_mb__after_clear_bit(); \
  156.     } while (0)
  157.  
  158. #define RPC_IS_QUEUED(t)    (test_bit(RPC_TASK_QUEUED, &(t)->tk_runstate))
  159. #define rpc_set_queued(t)    (set_bit(RPC_TASK_QUEUED, &(t)->tk_runstate))
  160. #define rpc_clear_queued(t)    \
  161.     do { \
  162.         smp_mb__before_clear_bit(); \
  163.         clear_bit(RPC_TASK_QUEUED, &(t)->tk_runstate); \
  164.         smp_mb__after_clear_bit(); \
  165.     } while (0)
  166.  
  167. #define rpc_start_wakeup(t) \
  168.     (test_and_set_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate) == 0)
  169. #define rpc_finish_wakeup(t) \
  170.     do { \
  171.         smp_mb__before_clear_bit(); \
  172.         clear_bit(RPC_TASK_WAKEUP, &(t)->tk_runstate); \
  173.         smp_mb__after_clear_bit(); \
  174.     } while (0)
  175.  
  176. /*
  177.  * Task priorities.
  178.  * Note: if you change these, you must also change
  179.  * the task initialization definitions below.
  180.  */
  181. #define RPC_PRIORITY_LOW    0
  182. #define RPC_PRIORITY_NORMAL    1
  183. #define RPC_PRIORITY_HIGH    2
  184. #define RPC_NR_PRIORITY        (RPC_PRIORITY_HIGH+1)
  185.  
  186. /*
  187.  * RPC synchronization objects
  188.  */
  189. struct rpc_wait_queue {
  190.     spinlock_t        lock;
  191.     struct list_head    tasks[RPC_NR_PRIORITY];    /* task queue for each priority level */
  192.     unsigned long        cookie;            /* cookie of last task serviced */
  193.     unsigned char        maxpriority;        /* maximum priority (0 if queue is not a priority queue) */
  194.     unsigned char        priority;        /* current priority */
  195.     unsigned char        count;            /* # task groups remaining serviced so far */
  196.     unsigned char        nr;            /* # tasks remaining for cookie */
  197. #ifdef RPC_DEBUG
  198.     const char *        name;
  199. #endif
  200. };
  201.  
  202. /*
  203.  * This is the # requests to send consecutively
  204.  * from a single cookie.  The aim is to improve
  205.  * performance of NFS operations such as read/write.
  206.  */
  207. #define RPC_BATCH_COUNT            16
  208.  
  209. #ifndef RPC_DEBUG
  210. # define RPC_WAITQ_INIT(var,qname) { \
  211.         .lock = SPIN_LOCK_UNLOCKED, \
  212.         .tasks = { \
  213.             [0] = LIST_HEAD_INIT(var.tasks[0]), \
  214.             [1] = LIST_HEAD_INIT(var.tasks[1]), \
  215.             [2] = LIST_HEAD_INIT(var.tasks[2]), \
  216.         }, \
  217.     }
  218. #else
  219. # define RPC_WAITQ_INIT(var,qname) { \
  220.         .lock = SPIN_LOCK_UNLOCKED, \
  221.         .tasks = { \
  222.             [0] = LIST_HEAD_INIT(var.tasks[0]), \
  223.             [1] = LIST_HEAD_INIT(var.tasks[1]), \
  224.             [2] = LIST_HEAD_INIT(var.tasks[2]), \
  225.         }, \
  226.         .name = qname, \
  227.     }
  228. #endif
  229. # define RPC_WAITQ(var,qname)      struct rpc_wait_queue var = RPC_WAITQ_INIT(var,qname)
  230.  
  231. #define RPC_IS_PRIORITY(q)        ((q)->maxpriority > 0)
  232.  
  233. /*
  234.  * Function prototypes
  235.  */
  236. struct rpc_task *rpc_new_task(struct rpc_clnt *, rpc_action, int flags);
  237. struct rpc_task *rpc_new_child(struct rpc_clnt *, struct rpc_task *parent);
  238. void        rpc_init_task(struct rpc_task *, struct rpc_clnt *,
  239.                     rpc_action exitfunc, int flags);
  240. void        rpc_release_task(struct rpc_task *);
  241. void        rpc_killall_tasks(struct rpc_clnt *);
  242. int        rpc_execute(struct rpc_task *);
  243. void        rpc_run_child(struct rpc_task *parent, struct rpc_task *child,
  244.                     rpc_action action);
  245. void        rpc_init_priority_wait_queue(struct rpc_wait_queue *, const char *);
  246. void        rpc_init_wait_queue(struct rpc_wait_queue *, const char *);
  247. void        rpc_sleep_on(struct rpc_wait_queue *, struct rpc_task *,
  248.                     rpc_action action, rpc_action timer);
  249. void        rpc_wake_up_task(struct rpc_task *);
  250. void        rpc_wake_up(struct rpc_wait_queue *);
  251. struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
  252. void        rpc_wake_up_status(struct rpc_wait_queue *, int);
  253. void        rpc_delay(struct rpc_task *, unsigned long);
  254. void *        rpc_malloc(struct rpc_task *, size_t);
  255. int        rpciod_up(void);
  256. void        rpciod_down(void);
  257. void        rpciod_wake_up(void);
  258. #ifdef RPC_DEBUG
  259. void        rpc_show_tasks(void);
  260. #endif
  261. int        rpc_init_mempool(void);
  262. void        rpc_destroy_mempool(void);
  263.  
  264. static inline void rpc_exit(struct rpc_task *task, int status)
  265. {
  266.     task->tk_status = status;
  267.     task->tk_action = NULL;
  268. }
  269.  
  270. #ifdef RPC_DEBUG
  271. static inline const char * rpc_qname(struct rpc_wait_queue *q)
  272. {
  273.     return ((q && q->name) ? q->name : "unknown");
  274. }
  275. #endif
  276.  
  277. #endif /* _LINUX_SUNRPC_SCHED_H_ */
  278.